Already Late on Day One
Week three. The submittal log is built, the trades have their assignments, and the project engineer is running the first real update. Everything on the log says pending — nothing is overdue, nothing is flagged, the tracking system is green top to bottom. He is ahead of schedule on the paperwork and he knows it.
The switchgear line catches his eye only because the equipment is expensive. He works it backward for his own peace of mind: it has to be energized in month fourteen, it ships on a lead time measured in the better part of a year, the manufacturer needs release-to-fabrication before that clock starts, the release needs approval, the approval needs a review cycle through the architect and the electrical engineer, and the sub needs time to assemble the package before any of that.
The math lands three weeks in the past. The submittal that everything on that chain depends on was due before the trade contract was signed. Nothing on the log is overdue, because nothing on the log has a deadline. The log has dates the sub typed in.
Why it happens
A submittal log tracks what has happened. It records the date an item was submitted, the date it came back, and what the stamp said. Every one of those is a fact about the past, and a system built out of them can tell you an item is late only after the lateness already exists.
The date that would have prevented the problem is a different kind of number. It has to be computed, not recorded — installation date, minus field lead time, minus delivery, minus fabrication, minus the release gate, minus the review cycle, minus resubmittal probability, minus the days the sub needs to build the package. Every one of those terms lives somewhere else: the installation date is in the schedule file, the fabrication window is with the manufacturer, the review cycle is in Division 01, and the resubmittal probability is in the trade’s history. Nothing in the tracking system reaches across all of them, so the deadline never gets calculated and the field left blank is the one that mattered.
What fills the gap is the sub’s own estimate. Asked when they will submit, a subcontractor gives a date that reflects their workload, not the project’s constraint — and that date goes in the log and becomes the plan. It is not a deadline. Nobody derived it from anything. And because it sits in the future, the item shows green.
The result is structural, not careless. At the moment a project starts, a handful of its longest-lead items are already behind, and every system on the job is designed to report them as fine. The first true signal arrives when the date the sub picked passes — which is months after the date the schedule actually required.
What it costs
Caught in week three, the fix is aggressive but ordinary. The item jumps the queue. The sub builds the package on an accelerated internal schedule. The review gets flagged for priority with the architect and the engineer, and the design team is told in writing why. Where the compression is not enough, the trade goes to an early release package — the long-lead item pulled out and released ahead of the full submittal — and the recovery costs some expediting and some goodwill.
Caught when the sub’s invented date slips, the recovery options are gone. The lead time is the lead time; no amount of escalation shortens a fabrication queue. The equipment lands after the space that receives it is finished, so the trades that were sequenced behind it are re-sequenced, and the ones already gone come back on remobilization. The schedule absorbs the difference or the completion date moves, and either way somebody is writing a delay claim about a submittal that was late before the project had a superintendent.
Between those two outcomes, the difference is not diligence. It is whether the deadline was a computed number or a number somebody typed.
Catching it early
The date has to be calculated for every item in the register, at kickoff, before anything is submitted.
Start from the schedule rather than the log. Pull the installation activity for each item out of the master schedule file — the actual dates and logic, not a summary somebody retyped — and work backward through every phase between approval and installation: field readiness, delivery, fabrication, the release gate that follows approval, the review cycle the contract specifies, and the days the sub needs to prepare. Size the buffer by complexity and by the trade’s rejection history, because an item that comes back once has spent another full cycle and the schedule never budgeted it.
That produces a submit-by date for every requirement in the register. Compare each one against today. Some of them will already be in the past — that is the check that makes the whole exercise worth running, and it only works if it is done at kickoff instead of discovered in month six.
Then keep the dates alive. The schedule updates monthly and the deadlines move with it, so the calculation reruns against the current file. The items with the least float and the most dependents get watched hardest. And when an item is genuinely unrecoverable, the notice goes out early with the analysis attached — the calculation showing what was required, when, and why the date could not be met — because a delay documented in week three is a schedule conversation, and the same delay discovered in month eight is a claim.
That is what Sentinel does. It reads the master schedule directly, works backward through every phase for every submittal in the register, and produces the deadline the log never had — including the ones that were already behind the day the job started. Procore shows you what’s late. Sentinel tells you what’s about to be.