A staffing coordinator counts the hours on every placement twice each week, once to pay the worker and once to bill the client. Those two numbers come from two sources that arrive on different days and almost never match. Friday morning gets spent reconciling them by hand.
How the client's timesheet arrives
At the client facility, the foreman or supervisor logs the hours. The agency does not run the clock. Whatever the client uses to capture time, a paper sign-in sheet or a building kiosk or a portal export, becomes the record the agency has to work from. The format, the accuracy, and the day it shows up are all the client's call.
Channels vary by client. One emails a scan of the signed timesheet on Monday. Another submits through a vendor portal that needs a login and a weekly export. A third emails the payroll coordinator directly, sometimes using a contact who left the agency months ago, and a fourth sends nothing until someone chases them. A coordinator covering thirty active placements across fifteen clients is tracking up to thirty separate submissions, every one from a different person and in a different shape.
By the time payroll has to close, some timesheets are in and some are not. The missing ones are not always late by the client's own clock. A client on a weekly billing cycle that settles Tuesday owes the agency nothing by Friday. The agency's payroll runs Friday to pay workers, and it does not wait.
The bill rate and pay rate problem
Every active placement carries two rates: the bill rate charged to the client and the pay rate paid to the worker. The spread is the margin. In the abstract that math takes ten seconds. It falls apart when the client's timesheet and the worker's record disagree about how many hours were worked, which shifts they applied to, or which job classification the hours fall under.
Say the client's signed timesheet shows an extra hour the worker never logged. Now there is an invoicing question: bill for what the client signed, or for what the worker recorded? A signed client timesheet usually controls for invoicing. But if the worker was not actually there for that hour, the agency has either billed wrong or paid for a shift nobody worked. The reverse hurts more. An hour the worker logged that the client's timesheet leaves out means the agency pays for hours it cannot bill, straight margin loss with no way to recover it.
Classification errors stack on top. A worker on a standard agreement earns overtime after forty hours in a week. When the client's timesheet does not split regular from overtime and the worker's record does, the two totals diverge before anyone starts reconciling. Each discrepancy carries a dollar amount, and each one waits on a person to pull both records, find the conflict, and settle it before payroll or the invoice can move an inch.
When the client has not approved
Standard practice in staffing is to invoice only against a signed client timesheet. The reason holds up: an unsigned timesheet is not an authorized billing event, and a dispute is easier to handle when the invoice matches a document the client already put their name on. Clients sign on their own schedule, though, not the agency's.
The approval gap opens between the end of the worker's week and the arrival of the client's sign-off. Workers expect to be paid on time no matter where client approval stands, and agencies pay them. Invoicing waits for the signature. So payroll closes against one record while invoicing sits in a separate queue, run by whoever is tracking which clients have returned timesheets.
That queue is usually a spreadsheet, a folder of email attachments, or whatever the coordinator can hold in their head. A normal week stays manageable. Now take a week where three clients have not returned timesheets, two placements carry classification questions, and one worker logged hours the client has not even seen. The queue turns into most of a day. The coordinator is not doing arithmetic, they are chasing approvals while the invoicing clock keeps running.
What a reconciliation layer closes
Workers already get tracked. Most agencies run some worker-side record, an app or a supervisor-confirmed portal entry or a structured intake, so adding another time-tracking method for them solves nothing. The gap is that the worker's record and the client's signed timesheet never sit side by side before payroll and invoicing run. Reconciliation happens by hand after both have already gone out, if it happens at all.
For one commercial staffing operation, we built a reconciliation tool that holds both records, worker hours and client-side timesheet, against each active placement for each week. The tool flags every discrepancy it finds: missing client approval, an hour count that does not match between the two sources, a classification conflict, an OT threshold applied one way on one record and another way on the other. Each flag is a numbered item with both source records visible and a fix field right there inline.
Worker pay processes once the worker-side record is confirmed. Client invoices generate once the signed timesheet lands and the two records agree. In a clean week the flag queue is empty, hours match, approvals are in, and payroll and invoicing close the same day. In a problem week the flags name the exact trouble: which placement, which shift, how many hours, which source is the outlier. Fixing one item does not mean rebuilding the whole week.
Before you build
Start with the rate table: every active placement, every client, every bill rate and pay rate and OT multiplier, checked against the actual invoices and payroll records from the last quarter. Agencies that grew through handshake rate agreements and client-by-client negotiation usually find this document does not live in any one reliable place. Building it takes about a day. It also drags out pricing surprises nobody was tracking, placements where the margin is thinner than anyone assumed and clients still riding rates set three years ago.
Next, the billing schedule. Some agencies bill weekly, some bi-weekly, some by project completion, and clients on the same roster often run on different schedules with different cutoff times. A reconciliation layer has to know what a closed week means for each client before it can call a timesheet overdue. Skip that and overdue has no definition, so the queue fills with noise.
Last, the approval workflow. How does each active client sign off, by email or portal or phone call or a physical signature? The answer changes from client to client and often from one relationship manager to the next. The approval path for each client has to be written down before any automation earns its keep. A tool that waits on email attachments from twelve contacts in twelve formats is still a manual tracking problem wearing a nicer label. Standardizing the submission method, even part way, is upstream work that pays back during the build and in every week after it.