Training reporting dashboards for training providers: what data to capture

Featured image with a powder blue and pink pastel background and a grid pattern, showing the post title "Training Reporting Dashboards: What Data to Capture"

Training reporting dashboards for training providers: what data to capture

Good training reporting starts with data capture, not charts. A dashboard can only be as accurate as the events behind it: when a seat was booked, when it was cancelled, who showed up, what was paid, and what the session’s capacity was on the day it ran. Get those right and every metric below can be computed.

The vendor reporting pages we reviewed name metrics such as fill rate without giving a formula, so two tools can report different numbers for the same sessions. This guide gives exact formulas for the core metrics, the events and fields each one needs, and a PostgreSQL query that was run on a small invented dataset.

Key takeaways

  • Capture append-only events with timestamps (booked, cancelled, attended, no-show) and snapshot capacity, price and time zone, instead of storing only a current status.
  • Define every metric by its unit, numerator, denominator and moment in time. Fill rate counts seats held when the session starts, not every booking ever made.
  • Treat an unmarked seat as unknown, not as attended or absent, and report roster completeness next to the no-show rate.
  • Start with live queries or materialized views on the operational database. Add a warehouse when you must join CRM, finance or marketing data.

What should training reporting answer for a training provider?

Training reporting should answer five operating questions: which sessions will run, how full they are, where seats are lost, what each seat earns, and whether instructors are used well. Learning outcomes such as assessment scores matter too, but they are a separate layer from the operating data covered here.

Different people ask different questions. Operations wants fill rate and time to confirm for upcoming sessions. Finance wants revenue per seat and cancellations. Delivery leads want attendance and instructor load. One shared dictionary keeps all three views consistent.

Why do two dashboards show different fill rates?

The same word often hides different formulas. One university data glossary calculates enrolled divided by room capacity, which counts booked seats. A fitness booking platform defines utilization as check-ins divided by capacity, which counts attended seats.

Both are useful, and they measure different things, so they need different names. Three silent choices cause most of the disagreement:

  • Unit: seats or registrations. A company booking five people is one registration and five seats.
  • Moment: today, at registration close, or when the session starts.
  • Denominator: capacity at which moment, and whether cancelled sessions are included.

The moment matters more than it looks. In the sample dataset used below, counting every booking ever made gives a September fill rate of 95.5%. Counting only seats still held when each session started gives 77.3%. The gap is seats that were booked and then cancelled.

How are the core training reporting metrics defined?

Define each metric by a unit, a numerator, a denominator and a moment in time. The table uses seats as the unit and the session start as the moment. Roll rates up from summed counts across sessions, not by averaging each session’s percentage, so a 4-seat class does not weigh the same as a 20-seat class.

Metric Exact formula Events and fields needed
Fill rate Seats held at session start / capacity at start Booked and cancelled events with timestamps; starts_at; capacity snapshot
Seat utilization Held seats marked attended / capacity at start Attended event per seat; roster closed flag
No-show rate No-show seats / seats held at start, only for sessions where every held seat is marked Attended or no-show event for each held seat; roster closed time
Cancellation rate Seats cancelled before start / seats ever booked, for sessions that ran or are scheduled to run Cancelled event with timestamp; who cancelled (learner or provider)
Late-cancellation rate Seats cancelled within N days of start / seats ever booked Same events, plus the policy window N
Session cancellation rate Sessions cancelled / sessions that reached their start date or were cancelled Session cancelled time and reason; minimum to run
Revenue per seat Available: net revenue from held seats / capacity. Held: the same revenue / seats held Net amount after discount and before tax at booking; currency; refunds
Time to confirm Median days from opened for registration to confirmed to run Opened time; confirmed time (minimum reached or go decision)
Instructor utilization Teaching hours delivered / hours the instructor was available, per period Availability windows with time zone; session start and end; cancelled sessions flagged

The definitions are our working design, not a standard. Change the windows and denominators to fit your policies, then write the result down and keep it fixed.

How do you count no-shows and cancellations without distorting them?

A no-show is a held seat explicitly marked absent. A seat nobody marked is unknown. Cancellations split by who cancelled and how close to the start. When a provider cancels a session, those seats are not learner cancellations, or your cancellation rate would blame learners for your own decisions.

The effect is large. In the sample, one October session has two held seats nobody marked. Counting them as attended gives a no-show rate of 5.0%. Counting them as no-shows gives 15.0%. Excluding that session until its roster is closed gives 8.3%. For the cancellation window itself, see the cancellation and waitlist rules post.

How do you calculate revenue per seat and instructor utilization?

Revenue per available seat divides net revenue by capacity, so every empty seat lowers it. Revenue per held seat divides by seats sold, so it reflects pricing and discounts. Instructor utilization divides delivered teaching hours by declared available hours. Decide in advance whether preparation and travel count as delivered.

Keep revenue net of discounts and before tax, and store a currency on every booking: never sum mixed currencies. Whether revenue lands at booking or at delivery is a finance decision, so agree it with them once. For available hours, subtract leave and holidays from contracted hours, and apply the same rule to every instructor.

Pro tip: Report capture quality beside the metric. Add “rosters closed / sessions delivered” to the same dashboard. A no-show rate computed from a minority of sessions is a sample, not a measurement, and readers should see that before they trust the number.

Which events and fields does training reporting need you to capture?

Capture two kinds of data: append-only events with timestamps (booked, cancelled, attended, no-show, session confirmed, session cancelled) and snapshots of fields that change (capacity, price, instructor, time zone). A current status alone cannot tell you what was true when the session started.

Five rules cover most of the work:

  1. Write one row per seat event and never overwrite a status.
  2. Snapshot capacity at session start, and price and discount at booking.
  3. Store every time as timestamptz together with the venue’s IANA time zone.
  4. Record who cancelled and why, and which window the cancellation fell in.
  5. Close each roster explicitly, so unmarked seats can be told apart from absent ones.

The entities behind these fields are described in the session, instructor and enrolment data model post, and attendance capture methods cover how the attended and no-show events get recorded.

What does the SQL look like?

A seat-level event table and a session table are enough to compute everything above. The queries below ran on PostgreSQL 16 against six invented sessions, and their output matched an independent calculation in Python. Table and column names are placeholders; adapt them to your schema.

CREATE TABLE sessions (
  session_id    int PRIMARY KEY,
  course_id     int NOT NULL,
  instructor_id int NOT NULL,
  tz            text NOT NULL,                -- IANA zone of the venue
  starts_at     timestamptz NOT NULL,
  ends_at       timestamptz NOT NULL,
  capacity      int NOT NULL CHECK (capacity > 0),
  min_to_run    int NOT NULL,
  opened_at     timestamptz NOT NULL,         -- opened for registration
  confirmed_at  timestamptz,                  -- go decision: minimum reached
  cancelled_at  timestamptz                   -- provider cancelled the session
);

CREATE TABLE seat_events (
  event_id    bigserial PRIMARY KEY,
  session_id  int NOT NULL REFERENCES sessions,
  seat_id     int NOT NULL,                   -- one learner, one seat
  event_type  text NOT NULL
              CHECK (event_type IN ('booked','cancelled','attended','no_show')),
  occurred_at timestamptz NOT NULL,
  net_amount  numeric(10,2)                   -- on 'booked': price after discount, before tax
);

This view reduces events to one row of counts per session. A seat is “held” if it was never cancelled, or was cancelled after the session started. The seven-day late window is a policy value to replace with yours.

CREATE VIEW session_metrics AS
WITH seats AS (
  SELECT session_id, seat_id,
         min(occurred_at) FILTER (WHERE event_type = 'cancelled') AS seat_cancelled_at,
         bool_or(event_type = 'attended') AS attended,
         bool_or(event_type = 'no_show')  AS no_show,
         max(net_amount)                  AS net_amount
  FROM seat_events
  GROUP BY session_id, seat_id
), flagged AS (
  SELECT s.session_id, s.capacity, s.starts_at, s.ends_at, s.tz,
         (s.cancelled_at IS NOT NULL) AS session_cancelled,
         st.seat_cancelled_at, st.attended, st.no_show, st.net_amount,
         (st.seat_cancelled_at IS NULL OR st.seat_cancelled_at > s.starts_at) AS held
  FROM sessions s JOIN seats st USING (session_id)
)
SELECT session_id, capacity, ends_at, session_cancelled,
       date_trunc('month', starts_at AT TIME ZONE tz)::date AS local_month,
       count(*)                                                    AS booked,
       count(*) FILTER (WHERE held)                                AS held,
       count(*) FILTER (WHERE held AND attended)                   AS attended,
       count(*) FILTER (WHERE held AND no_show)                    AS no_show,
       count(*) FILTER (WHERE held AND NOT attended AND NOT no_show) AS unmarked,
       count(*) FILTER (WHERE NOT held)                            AS cancelled_seats,
       count(*) FILTER (WHERE NOT held
                        AND seat_cancelled_at >= starts_at - interval '7 days') AS late_cancelled_seats,
       coalesce(sum(net_amount) FILTER (WHERE held), 0)            AS revenue
FROM flagged
GROUP BY session_id, capacity, starts_at, ends_at, tz, session_cancelled;

The monthly rollup sums counts across sessions and buckets each session by its own local month. It skips cancelled sessions and sessions that have not ended.

SELECT local_month,
       count(*)                                              AS sessions,
       round(100.0 * sum(held)     / sum(capacity), 1)       AS fill_rate_pct,
       round(100.0 * sum(attended) / sum(capacity), 1)       AS seat_utilization_pct,
       round(100.0 * sum(no_show)  FILTER (WHERE unmarked = 0)
                   / sum(held)     FILTER (WHERE unmarked = 0), 1) AS no_show_rate_pct,
       round(100.0 * sum(cancelled_seats)      / sum(booked), 1)   AS cancellation_rate_pct,
       round(100.0 * sum(late_cancelled_seats) / sum(booked), 1)   AS late_cancellation_rate_pct,
       round(sum(revenue) / sum(capacity), 2)                AS revenue_per_available_seat,
       round(sum(revenue) / sum(held), 2)                    AS revenue_per_held_seat
FROM session_metrics
WHERE NOT session_cancelled AND ends_at < now()
GROUP BY local_month
ORDER BY local_month;

On the sample data it returned the following. Amounts are invented and in a single currency.

Month Sessions Fill rate Seat utilization No-show rate Cancellation rate Late cancellation rate Revenue per available seat
September 2026 2 77.3% 68.2% 11.8% 19.0% 14.3% 340.91
October 2026 3 71.4% 60.7% 8.3% 4.8% 0.0% 373.21

The October no-show rate uses two of the three sessions, because the third roster was not closed. The local-month bucket also matters: one session starts at 20:00 UTC on September 30 but is October 1 in Sydney. Bucketing in UTC would have moved it into September.

Should training reporting run on live queries or a data warehouse?

For most training providers, start with live queries on the operational PostgreSQL database or a read replica, using materialized views for heavy rollups. Add a warehouse when you must join CRM, finance or marketing data, or keep history the application does not store. Seat-event tables for most providers are small by database standards.

PostgreSQL’s REFRESH MATERIALIZED VIEW CONCURRENTLY refreshes a view without locking out concurrent selects, provided the view has a unique index. That suits a nightly rollup of settled metrics such as no-show rate and utilization. Counts for open sessions can stay live.

These are signs you have outgrown live queries:

  • Report queries slow the booking path at peak registration times.
  • A metric needs data the TMS does not hold, such as campaign source or accounting entries.
  • You need to reproduce last quarter’s numbers after a definition or a price changed.

Pro tip: Version the definitions. Put each metric in a named view with its formula in a comment, and show that formula in the dashboard tooltip. When a definition changes, publish the new version beside the old one for a quarter so trend lines do not silently break.

What should you do next?

Pick three metrics, such as fill rate, no-show rate and time to confirm, and check that your current data can produce them. If a metric needs an event you do not record, add the event first, because history cannot be recovered later. Run the sample queries on a copy of your data and compare the result with a hand count for one session.

If you are choosing a platform rather than building, ask each vendor to export seat-level events and to show how every metric above is calculated. SimpliTrain’s TMS for professional training companies page lists scheduling, attendance, and payments and invoicing modules, and its demo page lists custom dashboards among the topics covered. You can request a SimpliTrain demo and bring this metric list.

Frequently asked questions

What is the difference between fill rate and utilization in training?

Fill rate counts seats held when the session starts, divided by capacity. Utilization counts seats where the learner actually attended, divided by capacity. The gap between them is no-shows plus seats nobody marked. Track both, because a full class with high no-shows still wastes instructor time and room capacity.

What is a good fill rate for instructor-led training?

There is no universal benchmark, so set your own from unit economics. Divide the session’s cost by the net price per seat to get break-even seats, then divide by capacity. For an invented example, a $4,000 session at $500 net per seat needs eight seats, which is 66.7% of a 12-seat class.

How do you calculate no-show rate for training?

Divide seats marked no-show by seats held at session start, and only include sessions where every held seat was marked attended or absent. Unmarked seats are unknown, so counting them either way distorts the rate. Show the share of sessions with closed rosters beside the percentage.

Should training reports count seats or registrations?

Count seats. A registration can cover several learners, and capacity, attendance and revenue all work at seat level. Keep the registration or order as a parent record for invoicing and client reporting, then roll seat-level facts up to it. Mixing the two units is a common cause of mismatched numbers.

Which time zone should training reports use?

Store every timestamp in UTC with the venue’s IANA time zone, then bucket days and months in the venue’s local time. A session that starts late in the evening UTC can fall on the next day locally. For virtual sessions, choose one rule, such as the host’s zone, and apply it everywhere.

How often should a training dashboard refresh?

Match refresh to when the number settles. Booking counts and fill rate for open sessions are worth near-live or hourly updates, because they drive sales and go/no-go decisions. No-show rate, utilization and revenue settle after the session closes, so a nightly refresh is usually enough. This is practical guidance, not a standard.

Alert: mundrisoftcareers.com is not affiliated with Mundrisoft Solutions. Beware of fake job offers and trust only our official recruitment channels.