Stop Taking the Register on Faith

Every pay period, a file arrives at the hall. It lists shift after shift, member after member: hours, wages, dues withheld. Thousands of lines.
And at most locals, that file is taken on faith.
Not because anyone is careless, but because there's no realistic way to check it by hand. A dedicated staff member can work through one pay period line by line, slowly. Nobody can do it for every period, every year, while also running the hall. So the register gets filed, the remittance gets logged, and everyone hopes the numbers were right.
DockOps exists so your local doesn't have to hope.
Why check-off is harder to verify than it looks
Dues check-off sounds simple. Dues are withheld from each member's pay and remitted to the local along with a register showing what was withheld. In practice, verifying it means doing three different jobs at once:
First, recomputing what should have been withheld for every shift line, under your local's own dues rules, and comparing it to what the register says was withheld.
Second, comparing what was withheld with what the local actually received.
Third, noticing patterns that only show up across many periods: a member whose hours suddenly drop out of the data, a batch of lines with no dues recorded, a setup error that repeats week after week.
The errors that matter most are almost never visible in a single file. They show up when periods are compared side by side. That's exactly the kind of work people are bad at and software is good at.
From employer remittance to local-verified record
DockOps changes the starting point. Instead of the register being the only record, the local has its own: dispatch, check-in, check-off and timesheets recorded as the work happens, tied to the work order, gang, job code and date.
When check-off registers come in, DockOps imports them as they arrive and detects duplicate files automatically, so the same period isn't counted twice. Then it runs the checks a careful secretary-treasurer would run if they had unlimited time:
Recompute versus withheld. For each shift line, expected dues are recalculated under your local's dues rules and compared with what was withheld. Lines where the two don't match are flagged for review.
Withheld versus received. For each period, the amount withheld on the register is compared with what the local received, once remittance detail is available.
Cross-period patterns. Members whose hours or wages change sharply or disappear between periods are flagged. There are often ordinary explanations, but it's worth a question.
The result is an exception report, not an accusation. Every flagged item links back to the source file and the specific lines behind it.
Discrepancies are questions, not conclusions
This part matters, so it's worth saying plainly: a flagged line is not a confirmed shortfall. It's a discrepancy that needs review.
A uniform gap across an entire period might be a payroll setup issue. A single line might reflect a late correction. A member's missing hours might have a perfectly good explanation. The point of reconciliation isn't to assume the worst. It's to catch discrepancies early so they can be reviewed, verified and corrected while the details are still fresh and the records are still easy to find.
That's why DockOps keeps the evidence with every finding: the member, the work period, the source record and the running balance. When a question goes to whoever needs to verify it, it goes with documentation, not a general concern. And DockOps tracks what was verified, corrected or settled over time, so nothing falls through the cracks between one officer's term and the next.
Accurate records protect everyone. Clean reconciliation means fewer surprises, faster corrections and less friction for all parties.
Every period, not once a year
The biggest change isn't the depth of the analysis. It's the timing.
When reconciliation is a manual project, it happens rarely, if at all. When it's built into the system, it can run every time a new register arrives. Issues get caught in weeks rather than discovered a year later, when they're harder to untangle and members have long since stopped remembering which shift was which.
Locals can also look back. Every year of records the local can provide is a year that can be checked. Old registers sitting in a box become a usable history instead of a storage problem.
Your dues rules, not a template
Dues structures vary from local to local: categories, billing periods, rates, how arrears are handled. A generic tool that assumes one structure will produce noise instead of answers.
DockOps applies your local's own dues rules and records. The analysis is configured to how your local works, so the exceptions it raises are the ones that actually matter to your hall.
What members get out of it
It's easy to think of reconciliation as back-office work. It isn't. It's one of the most direct ways a local can make sure members get credit for what they earned.
When a member's dues are recorded correctly, their standing is right. When their hours are captured accurately, their record is right. When a discrepancy appears, the local can catch it and get it reviewed instead of waiting for the member to notice on their own.
And members can see more for themselves. In DockOps, members see their logged hours in the app the same day and can flag a discrepancy while the work is fresh. The local's authorized staff review corrections, and every correction keeps the original and its history.
The shift
The old paradigm: the register arrives, and the local trusts it.
The new paradigm: the register arrives, and the local checks it against its own record, every period, with evidence attached to every question.
That's not adversarial. It's just good stewardship of the money members earned.
See what reconciliation would look like at your local. Book a demo at dockops.app/book.
— The DockOps Team