Most payroll systems were built around a simple assumption: you work hours, you get paid for hours. Adjunct and session-based work breaks that assumption completely. An adjunct instructor doesn't clock in for eight hours — they teach a 90-minute section, maybe hold a 30-minute office hour, and that's the whole billable unit. Tutoring centers, music schools, driving schools, physical therapy clinics, and contract trainers all run on the same logic.
The problem is that session-based work sits in an awkward middle ground. It's not hourly, and it's not salaried. And the moment a session gets cancelled, rescheduled, or turned into a makeup class, the whole mapping from "what happened" to "what gets paid and billed" falls apart. That's where most of the disputes live.
This post stays narrow on purpose. We're going to work through how to actually define a session in your rules, how to export those sessions so billing and payroll don't disagree, how often managers should approve, and — the part everyone underestimates — the edge cases around cancellations and makeups that quietly leak money.
Why session definitions cause more trouble than hourly rules
The core issue is that a session isn't a timestamp. It's a bundle. A single tutoring session might include the actual contact time, prep time, travel time, and a cancellation window. Depending on the contract, some of those pieces are billable to the client, some are payable to the instructor, and some are neither.
In practice, this usually breaks down when the same session has two different "lengths" — the scheduled length and the actual length. An instructor is booked for a 60-minute session, the student shows up 15 minutes late, and the instructor teaches 45 minutes. Now:
-
Does the client get billed for 60 or 45?
-
Does the instructor get paid for 60 or 45?
-
Who absorbs the 15-minute gap?
If your rules don't answer all three of those cleanly, your front desk is improvising — and improvising is where disputes come from.
The businesses with the worst session-billing problems almost never have a bad payroll system. They have a fuzzy session definition that forces humans to interpret every edge case manually. The system is fine. The rulebook has holes.
A session definition that actually survives payroll
Before you touch exports or approvals, nail down the anatomy of a session. A session definition that holds up has these fields, and every one of them needs a default rule:
Accurate time tracking made effortless.
GoTimio empowers your team to log, monitor, and manage work hours seamlessly.
- Real-time time tracking
- Automated timesheet approvals
- Payroll and billing integration
No credit card required
| Session field | What it captures | Billing impact | Payroll impact |
|---|---|---|---|
| Scheduled duration | Booked length | Default bill basis | Default pay basis |
| Actual duration | Time delivered | May override bill | May override pay |
| Session type | Regular / makeup / trial / group | Different rate | Different rate |
| Attendance status | Attended / no-show / late-cancel | Triggers bill rule | Triggers pay rule |
| Prep/admin allowance | Fixed add-on if any | Usually non-billable | Often payable |
| Location modifier | On-site / remote / travel | Travel surcharge | Travel stipend |
The piece people skip is session type. They treat a makeup class as if it's identical to a regular one — it almost never is. A makeup session is often payable to the instructor but not billable to the client, because the client already paid for the original. If your session record doesn't flag the type, that distinction gets lost at export, and you end up either double-charging a parent or paying an instructor twice for the same slot.
Write down the default rule for every combination of session type and attendance status. Not the happy path — the default. "Regular session, no-show, more than 24 hours notice" needs a defined answer before it happens, not after an angry email comes in.
The export problem: one event, two destinations
A session is a single real-world event, but it has to feed two different systems — billing (what the client owes) and payroll (what the worker is owed). Those two systems care about different fields of the same record, and if you export them separately, they drift.
A typical example: a music school runs sessions in their scheduling tool. At month-end, an admin exports a billing report and separately exports a payroll report. The billing report pulls scheduled durations. The payroll report pulls actual clock times. Any session where actual time differed from scheduled time now shows a mismatch — the parent is billed for 30 minutes the instructor wasn't paid for, or vice versa. Multiply that across a few hundred sessions and the numbers stop reconciling.
The fix is to export from a single session ledger, where each row carries both the billing basis and the payroll basis explicitly. One record, two mapped amounts, generated at the same moment from the same source of truth.
A clean export row should carry, at minimum:
-
Session ID (unique, immutable)
-
Date, scheduled start/end, actual start/end
-
Session type and attendance status
-
Client/account ID and the billable amount with the rule that produced it
-
Worker ID and the payable amount with the rule that produced it
-
Approval status and approver
When the billable and payable amounts live on the same row, reconciliation stops being a monthly archaeology project. You can diff the two columns and investigate only the rows where they diverge for a reason you didn't expect. If you're already running a pre-billing reconciliation process, this single-ledger export is what makes that reconciliation fast instead of painful.
A simple export-mapping workflow
-
Session gets delivered and marked with actual times + attendance status.
-
The rule engine applies the session-type/attendance rule and writes both the billable and payable amount to the same record.
-
Manager approves the session (or a batch of sessions).
-
Approved sessions are locked — no silent edits after lock.
-
One export job produces the billing feed and the payroll feed from the identical locked dataset.
-
A reconciliation check flags any row where billable-vs-payable differs outside the expected rules.
Quick visual of that workflow:
The order matters. Approval happens before lock, and export happens after lock. Skipping the lock step is the single most common reason a corrected session in week three retroactively changes a number that already went out on an invoice.
Manager approval cadence: how often is right
Approval cadence is where businesses tend to go to one of two extremes. Either managers approve nothing until month-end — and then face a wall of 400 sessions they can't possibly review honestly — or they're asked to approve every session individually, which turns into rubber-stamping within a week.
The cadence that actually works is tied to your billing cycle and your dispute window, not to a calendar habit.
Weekly batch approval fits most session-based businesses. It's recent enough that a manager still remembers the context ("yeah, that Tuesday class got cut short because of the fire drill"), and it's small enough to review without numbing out. By the time month-end arrives, the sessions are already blessed.
Approve-on-exception is the upgrade. Instead of approving all 400 sessions, the manager approves only the ones the rule engine flags — makeups, no-shows, late cancels, duration mismatches beyond a threshold, anything with a travel modifier. In a healthy month, that might be 30–40 sessions out of several hundred. Everything on the happy path auto-approves.
Approval quality drops sharply once a manager has more than roughly 40–50 items in front of them. Beyond that, they stop reading and start clicking. The real goal of your cadence isn't "approve more" — it's shrink the approval queue to the sessions that genuinely need a human judgment.
A reasonable approval checklist for the exception queue:
-
[ ] Does the session type match what actually happened? (A makeup marked as regular is the most common error.)
-
[ ] Is the attendance status correct, and does it match the notice window?
-
[ ] For duration mismatches, is the billable basis the one the contract specifies?
-
[ ] For makeups, is the client correctly not being re-billed?
-
[ ] For travel/location modifiers, is there a corresponding scheduled location?
-
[ ] Any session edited after delivery — who edited it and why?
Set exception thresholds so managers only review sessions the rule engine flags, keeping weekly queues under ~50 items.
The real goal of your cadence isn't "approve more" — it's shrink the approval queue to the sessions that genuinely need a human judgment.
The edge cases that actually leak money
Regular sessions are easy. The money leaks happen in the four or five situations nobody wrote a rule for. Below are the edge cases worth building explicit test cases around — meaning, you should be able to run a fake session through your system for each one and verify the billing and payroll outputs before you trust the month-end numbers.
Cancelled sessions
The variable is notice. A cancellation with 48 hours notice is usually a clean $0/$0 — nobody billed, nobody paid. A late cancel (say, under 24 hours) often triggers a client charge and sometimes a partial instructor payment, because the instructor held the slot and can't rebook it.
-
Cancel with full notice → bill $0, pay $0.
-
Cancel inside the notice window → bill at late-cancel rate, pay the hold rate (if any).
-
No-show (nobody cancelled, student just didn't come) → bill full, pay at your no-show rule.
-
Instructor-initiated cancellation → bill $0, and decide whether a makeup is auto-created.
The trap is treating "cancelled" as one status. It's at least four. The notice window and who cancelled change the money every time.
Makeup sessions
Makeups are the biggest silent leak. The original session was already billed and paid. The makeup is the replacement delivery. If your rules don't link the makeup back to the original, you risk billing the client twice — once for the original, once for the makeup.
The clean rule: a makeup session is payable to the instructor (they did the work the second time) but billed at $0 to the client if the original was already billed. If the original was refunded or credited, then the makeup becomes billable again. That linkage — makeup → original session ID — is non-negotiable. Without it you're guessing.
-
Makeup linked to a billed original → pay instructor, bill $0.
-
Makeup linked to a refunded original → pay instructor, bill full.
-
Makeup with no linked original (data entry error) → should fail validation, not silently bill.
Partial sessions and overruns
A session that ran long or short needs a defined basis. Pick one and apply it consistently: bill the scheduled amount, bill the actual amount, or bill actual-rounded-to-a-block. Each is defensible. Mixing them per-session is not.
Trial and first sessions
Trials are often discounted or free to the client but still payable to the instructor. Flag them as their own type so they don't get swept into regular billing.
Real scenario: a regional tutoring company
A mid-sized tutoring company running roughly 900–1,000 sessions a month across about 30 tutors had a recurring month-end mess. Billing and payroll were exported from two different views of the same scheduling tool. The admin spent close to two full days each month chasing mismatches manually, and parents regularly disputed charges on sessions that had been makeups.
The specific leak: makeups weren't linked to their originals, so somewhere around 20–30 sessions a month were being billed twice — once as the original, once as the makeup. Some parents caught it and got refunds (disputes, bad will), and some didn't (a slow-building trust and compliance problem). On the payroll side, a handful of late-cancel sessions were being paid at the full rate instead of the hold rate.
The changes weren't dramatic. They added a session type flag with an enforced makeup→original link, moved to weekly exception-based approval so team leads reviewed only the flagged sessions, and switched to a single-ledger export carrying both billable and payable amounts per row.
After a couple of billing cycles, month-end reconciliation dropped from roughly two days to a few hours. Unlinked makeups now failed validation instead of slipping through, so the double-billing effectively stopped. The bigger win was qualitative — parent disputes about makeup charges mostly disappeared, which matters more than the raw time saved.
When strict session rules make sense — and when they don't
This approach makes sense when: you run high session volume, multiple session types, and you bill clients and pay workers off the same events. The more your makeups, cancellations, and trials differ in treatment, the more a formal definition pays off.
It's overkill when: you run a handful of sessions a week, all the same type, all billed and paid identically. If you have 20 sessions a month and no makeups, a spreadsheet with a cancellation column is genuinely fine. Don't build a rule engine for a problem you don't have.
Who should be careful: businesses mid-transition — growing from "a few sessions" to "a lot of sessions." That's the danger zone. The old spreadsheet habits survive right up until the volume makes them unworkable, usually around the point where one person can no longer remember the context of every session that happened this month.
Getting the records to hold up later
Session records are also evidence. When a parent disputes a charge four months later, or an instructor questions a paycheck, you need the original session record — type, times, attendance, approver, and the rule that produced each amount — intact and retrievable. That's a retention question as much as a billing one, and it's worth thinking about how long you keep these locked records and in what form, especially as volume grows. The same tiering logic in a timesheet retention cost strategy applies cleanly to session ledgers.
The throughline across all of this: session-based billing doesn't fall apart because the math is hard. It falls apart because "session" was never fully defined, so every cancellation and makeup becomes a judgment call made under time pressure. Define the session completely, export it from one ledger, approve the exceptions rather than everything, and write a test case for each edge case before it costs you. The regular sessions were never the problem — it's the ones that didn't go as planned that decide whether your numbers reconcile.
The throughline across all of this: session-based billing doesn't fall apart because the math is hard. It falls apart because "session" was never fully defined, so every cancellation and makeup becomes a judgment call made under time pressure. Define the session completely, export it from one ledger, approve the exceptions rather than everything, and write a test case for each edge case before it costs you. The regular sessions were never the problem — it's the ones that didn't go as planned that decide whether your numbers reconcile.
Ready to optimize your workforce time management?
Join 2,000+ companies using GoTimio to improve timesheet accuracy, reduce payroll errors, and boost team productivity.