A payroll processing engine that ingests enrollment data, applies course-type-specific rate schedules, and generates formatted Excel payroll reports, replacing a manual process that took days with one that runs in seconds.
Every pay period, a small team in the department sat down with a massive Excel workbook and began the same grueling ritual: manually calculating instructor compensation. Each course had its own rate structure. Lectures paid differently than labs, online sections used a separate multiplier, and supervision courses followed yet another formula. A single instructor might teach across all four types in a single term, and every line had to be calculated by hand.
The spreadsheet had grown organically over the years into a labyrinth of nested formulas, conditional references, and color-coded cells that only one or two people fully understood. When enrollment numbers shifted mid-term (a common occurrence), the recalculations cascaded across dozens of rows. One miskeyed number could mean an instructor was overpaid or underpaid by hundreds of dollars, and the error might not surface until someone filed a complaint weeks later.
The toll wasn't just financial. Administration spent two to three days every pay period locked in this process, unable to attend to other responsibilities. The department needed a system that could ingest raw enrollment data, apply the correct rate schedule for every course type, and produce a clean, auditable payroll report, all without anyone touching a formula.
Payroll calculations consumed two to three full days every pay period. Staff couldn't get to anything else until it was done.
Lectures, labs, online sections, and supervision courses each followed different pay formulas. A single instructor's compensation could span multiple overlapping rate schedules.
Miskeyed numbers and broken formulas led to overpayments and underpayments that cost the institution real money and eroded trust with instructors.
The payroll workbook was a tangle of nested formulas and conditional formatting that only one or two people could maintain. It was a single point of failure for the entire process.
Sat with administration to reverse-engineer every pay formula from the existing spreadsheets. Documented rate tables for lectures, labs, online courses, and supervision sections, including enrollment-based multipliers and edge cases that only existed as tribal knowledge. These became the formal rules the engine would enforce.
Designed a classification engine that automatically identifies whether each course section is a lecture, lab, online, or supervision course based on enrollment data patterns and section codes. This eliminated the manual tagging step, which was tedious and error-prone. The correct rate schedule gets applied every time.
Built a Flask-based processing pipeline using Pandas for data transformation: upload an enrollment Excel file, the engine parses it, joins it against predefined rate schedules, calculates compensation per instructor per section, aggregates totals, and flags any data inconsistencies for review. The whole thing runs in seconds.
Used openpyxl to produce print-ready Excel payroll reports that matched the institution's existing formatting standards. Administration received a familiar-looking output they could review and forward. No change to their workflow, just faster results without calculation errors.
If your team spends days every pay period wrestling with rate tables, enrollment-based formulas, and formatting reports, there's a better way. Let's talk about what an automated payroll engine could look like for your department.
Start a ConversationUpload raw enrollment data as an Excel file through a clean web interface. The engine parses, validates, and flags missing or malformed records before processing begins.
Automatically classifies each section as lecture, lab, online, or supervision based on section codes and enrollment patterns. The correct rate schedule is applied without any manual tagging.
Pay rates scale dynamically with enrollment counts. The engine applies tiered multipliers defined in the rate schedule, so compensation adjusts automatically as class sizes change.
Rate tables for every course type are configured once and reused across terms. Administration can update rates without touching code. Just edit the schedule and rerun.
Generates print-ready Excel payroll reports that match the institution's existing formatting standards: headers, subtotals, and per-instructor breakdowns included.
Every calculation is traceable. The system logs data inconsistencies, flags mismatches between enrollment records and rate schedules, and produces a summary report so administration can verify results before approval.
The web interface accepts enrollment Excel files and immediately validates the data. Missing fields, unrecognized course codes, and formatting issues are flagged before any calculations begin.
A real-time view of the payroll calculation pipeline. Each instructor's sections are classified, matched to rate schedules, and calculated into final compensation with enrollment multipliers.
The final payroll report, generated as a formatted Excel file. It matches the institution's existing layout with per-instructor breakdowns, course-type subtotals, and a grand total ready for approval.
The biggest adoption win was keeping the workflow in Excel. Administration didn't want a new dashboard or a login portal. They wanted to upload the file they already had and get back a report in the format they already used. Matching their mental model made the tool invisible: it just worked, and nobody had to learn anything new.
The rate schedules weren't documented anywhere formal. They lived in the heads of two people and in the formulas of a spreadsheet nobody else dared edit. Extracting those rules and encoding them as explicit, testable logic was the hardest part of the project, and the most important. When one of them eventually left, the system kept running without missing a beat.
The payroll engine's most appreciated capability isn't speed, it's the data validation layer. Catching a missing enrollment record or a mismatched section code before calculations run prevents the kind of silent errors that used to surface weeks later as payroll disputes. Building trust in the output required proving the system would refuse to produce bad results.
If your team still spends days every pay period on instructor compensation in spreadsheets, I've already solved this problem. Let's talk about building a payroll engine tailored to your institution's rate structures.
No pitch. No pressure. Just a conversation about what might work.