On most jobs there are two schedules living side by side, and they don't talk to each other. There's the CPM schedule the scheduler built in the home office — the one with the milestones, the logic ties, the float, the thing that gets emailed to the owner once a month. And there's the schedule that actually runs the job: the look-ahead the super and the trade foremen build in the trailer, the weekly work plan taped to the wall, the sticky notes and the whiteboard. One of them is the contract. The other one is the truth. When those two never reconcile, you get the same headache every project controls person knows by heart — the master schedule says you're on track, the field knows you're two weeks behind, and nobody finds out which is right until the monthly update.
Integrating the Last Planner System with project controls isn't about buying more software. It's about making the field's short-interval planning and the office's cost-and-schedule reporting draw from the same set of facts, so you stop maintaining two versions of reality and paying people to reconcile them once a month.
Why the two schedules drift apart
They drift because they're built for different jobs and updated on different clocks. The CPM schedule answers "are we going to hit the milestone dates in the contract?" It's activity-based, logic-driven, and it updates monthly at best. The look-ahead answers "what can we actually get done in the next three weeks, and what's in the way?" It's constraint-driven, it changes daily, and the foremen own it.
The gap shows up in a few predictable ways:
- Double entry. Someone types progress into the CPM tool, and someone else types the same progress into the field's tracking. The two never quite match.
- Different granularity. One CPM activity — "Level 3 Interior Rough-In," 15 days — is fifty things on the field's plan: MEP overhead by room, top-out, in-wall, inspection holds. The office reports 40% complete; the field knows the east wing is done and the west wing hasn't started, which is a completely different risk profile.
- Stale status. By the time the monthly update captures a problem, the field solved it, worked around it, or let it metastasize three weeks ago.
The fix isn't to pick one schedule and throw the other away. You need both. The CPM schedule is the contract framework and the claims record; the look-ahead is how work actually gets planned and committed. What you're integrating is the flow of information between them.
Top-down: what the master schedule owes the look-ahead
The master schedule should be the source of the boundaries the field plans inside. Before a super builds a three- or six-week look-ahead, the CPM schedule hands down four things:
- Milestones and hard dates. Owner-driven turnovers, permanent power, dry-in, TCO. These don't move because a foreman wants them to.
- Sequence logic. The dependencies that are real — you can't close a wall before rough-in inspection, you can't top out before the deck above is poured and shored.
- The activities to explode. Each CPM activity that lands inside the look-ahead window gets broken down into the make-ready tasks and daily assignments the field commits to.
- Known constraints. Long-lead equipment, permit dates, phasing restrictions the owner imposed.
Here's the discipline that makes this work: the look-ahead is where you pull work forward and make it ready, but it never quietly violates the master logic. If the field decides to run a sequence the CPM doesn't allow — and sometimes the field is right and the CPM is wrong — that's a conversation with the scheduler, not a silent workaround. Otherwise you end up committing crews to work that inspection or a predecessor won't let you finish, and your Percent Plan Complete craters for reasons that were baked in before the week started.
Bottom-up: what the look-ahead owes project controls
This is the direction most teams get wrong, and it's the more valuable one. The field is standing on the actual work. It knows the truth first. Project controls should be pulling that truth up, not guessing at it from a desk.
Three things flow up from the weekly work plan and look-ahead:
- Ground-truth progress. Not "40% per the update" — actual completed work, room by room, pour by pour. This is the physical percent complete that should be driving earned value, not a straight-line assumption.
- Real durations. The look-ahead is a running experiment in how long things actually take with your crews on this building. When drywall hang is running 20% slower than the CPM assumed across three floors, that's not a one-off — that's a duration your scheduler needs to fix in the forecast now, not discover at substantial completion.
- New constraints and the reasons for variance. Every task that didn't get done last week has a reason — a late submittal, a missing inspection, an RFI, a trade that didn't show. Those variance reasons are the single most useful data project controls can collect, because they tell you what will keep hurting you if you don't fix the underlying system.
A well-run look-ahead process already captures all of this. The integration job is making sure it doesn't die in the trailer — that the field's tracking feeds the reporting instead of being retyped, guessed at, or ignored.
Tying schedule to cost and earned value
Earned value only works if the "value earned" reflects work that actually happened. That's exactly what the Last Planner System produces, so the two are natural partners — if you connect them.
The mechanical piece is a common coding structure. Your CPM activities, your cost codes, and your look-ahead tasks should map to each other cleanly enough that physical progress in the field rolls up to budgeted-cost-of-work-performed without a translation committee. When a foreman marks a location complete, that should be traceable to the cost code that earns value for it. Get the coding right up front and the rest is arithmetic; get it wrong and you'll spend every month arguing about which system is lying.
There's also a quieter, more powerful link between look-ahead performance and forecast accuracy. Percent Plan Complete is a leading indicator of your Estimate at Completion. A crew that reliably hits 75%+ of its weekly commitments is a crew whose remaining durations you can trust. A crew running at 45% PPC is going to blow through its remaining budget and schedule, and PPC tells you that months before the cost variance shows up in the numbers. If your project controls forecast ignores field reliability, it's an optimistic guess dressed up as analysis.
Getting the update cycles to line up
Integration falls apart at the seams between clocks. The field plans weekly; the master schedule updates monthly; progress happens continuously. If those cycles aren't nested deliberately, data goes stale in the gaps.
The pattern that holds up: the weekly work plan and look-ahead update every week, and that weekly progress data accumulates into the monthly master schedule update. Four weeks of real field progress and real variance reasons should feed the monthly, so the update is a summary of what the field already knows — not a fresh archaeology dig where the scheduler chases foremen for numbers the Friday before it's due. When the monthly update is just a roll-up of data you've been capturing all along, it takes an afternoon instead of a week, and it's actually right.
Who owns what
Integration dies without clear ownership. Three roles, and they need to overlap on purpose:
- The master scheduler owns the CPM schedule — logic, milestones, the contract baseline, the forecast.
- The superintendent and trade foremen own the look-ahead and the weekly work plan — make-ready planning, commitments, daily execution.
- Project controls owns the connection — the reporting, the earned value, and making sure the two schedules reconcile instead of drifting.
The failure mode here is a scheduler who builds a beautiful CPM schedule the field never looks at, and a super who runs the job off a whiteboard the office never sees. Both people are working hard. Neither one is wrong. But nobody owns the handshake, so there isn't one. A short standing meeting — scheduler and super, weekly, walking the look-ahead against the master — does more for schedule accuracy than any tool, because it forces the two versions of reality to reconcile out loud in front of the people who can fix them.
How the systems actually connect
There are a few technical routes, roughly in order of how much you'll fight them:
- One platform for both. When the same system holds the CPM-level framework and the field's look-ahead and weekly work plans, there's nothing to reconcile — progress entered once shows up everywhere. This is the cleanest option when the tooling fits how your team works.
- API integration. Two systems, automatic data exchange. Powerful, but someone has to own the mapping and babysit it when either tool updates.
- Export/import. Manual transfer on a schedule. Honest and cheap, but it's only as current as the last export, and every manual step is a place data goes stale.
Tool choice matters less than the habit. Plenty of teams achieve real integration with a disciplined weekly cadence and a spreadsheet; plenty of teams buy expensive integrated platforms and still run two disconnected schedules because nobody changed how they work. This is where purpose-built look-ahead software earns its keep — a tool like LookAheadWall keeps the field's location-based weekly plan and trade-flow sequences in one shared place the super, the foremen, and the subs all see, so the ground-truth the office needs is already captured as a byproduct of planning the work, not a separate reporting chore bolted on after. The point is to make the field's planning and the office's controls feed each other by default, so nobody has to remember to reconcile them.
The payoff — and it's not just tidier reports
Beyond killing double entry, integration quietly builds the record that saves you when a job goes sideways. A look-ahead updated weekly, with variance reasons attached, is a contemporaneous record — activity-level, dated, showing exactly when a late submittal or a missing inspection first hit the field and how it rippled. When a delay claim shows up eighteen months later, that trail is worth more than any after-the-fact narrative, because it was written down while it was happening and nobody was building a case yet.
What integration failure looks like — and how to avoid it
Four ways it goes wrong, all of them common:
- Permanent silos. The two schedules are simply never connected. The scheduler and the super run parallel universes and meet at the monthly update to argue.
- One-way flow. The master schedule dictates down but nothing flows back up. The field's hard-won knowledge about real durations and real constraints never reaches the forecast, so the forecast stays wrong.
- Stale data. Updates too infrequent to matter. Monthly-only reporting on a job where the ground moves weekly means you're always steering by a map that's a month old.
- Unreconciled conflict. Both systems get updated, but nobody makes them agree, so leadership gets two numbers and picks whichever one they like better.
The common thread: none of these is a software problem. They're process problems. You fix them with clear ownership, a nested weekly-into-monthly cadence, and the discipline to let the field's truth flow up into the forecast instead of overwriting it with wishful thinking.
If you take one thing from this: design the handshake between your look-ahead and your project controls at the start of the job, when the coding structure is still clay and habits haven't set. Integration is cheap to build in and brutal to retrofit. Get the field and the office drawing from the same facts on day one, and you'll spend the rest of the project managing the work instead of arguing about which schedule to believe.