You're three weeks past delivery. The project manager pulls up the final numbers for the closeout review. Revenue came in where you expected. Costs didn't.
Someone in the room says it out loud: this one barely broke even. Another voice points out it actually lost money once you count the hours that never got logged against the project code.
Now you're doing forensics. Pulling subcontractor invoices from accounting. Cross-referencing time entries from your PM tool. Asking the lead consultant to remember which meetings were billable. The answer eventually surfaces, but it doesn't matter anymore — the money is already spent.
The uncomfortable part isn't that this project lost money. It's that nobody knew until it was too late to do anything about it.
Here's the structural reason this keeps happening. Your sales team closed the deal in your CRM. Operations is executing it in a project management tool. Costs — subcontractors, software licenses, billable hours, travel — get recorded in your accounting system or a finance spreadsheet.
Three systems. Three sources of truth. None of them showing you margin in real time.
To know what a project is actually costing you right now, someone has to manually pull data from all three, reconcile it in Excel, and present it in a meeting. That's a job, and it's a job nobody owns end-to-end. So it doesn't happen weekly. It happens at the end, when the project is already closed.
The result is a structural blind spot. You're not running projects with visibility — you're running them on the assumption that the original quote was accurate and that nothing material has changed. By the time you find out something did change, the decisions that would have mattered are already in the past.
The first attempt is usually a weekly margin report. Someone in finance or operations gets assigned to pull the numbers every Monday and circulate a spreadsheet. It works for about six weeks. Then a deadline hits, the report gets skipped, and within two months it's quarterly. Then it's gone.
The second attempt is a dashboard built on top of one of the three systems — usually the project management tool. It shows hours logged versus hours budgeted. It does not show subcontractor costs that haven't been invoiced yet, software licenses charged to the project, or the senior consultant's time that got logged to a different code. The dashboard looks healthy. The margin isn't.
The third attempt is integration through APIs or a BI tool stitching everything together. This works technically. It also takes six months to build, breaks every time one of the systems updates, and produces reports that nobody on the operating team trusts because the numbers don't match what they remember.
None of these approaches fail because the people executing them are bad at their jobs. They fail because the underlying architecture is wrong. You can't get real-time margin out of three disconnected systems by reporting harder on top of them.
The fix is structural, not procedural. Margin has to live in the same place the project lives, and every cost has to be associated with the deal as it happens — not reconciled at the end.
Concretely: when a subcontractor invoice comes in, it gets logged against the deal it belongs to. When a software license is purchased for a specific client engagement, same thing. When billable hours are logged, they're tied to the deal. The deal itself carries a running total of every cost associated with it, automatically rolled up against the contract value.
Now your sales director can open any active project and see, in ten seconds: contract value, costs to date, costs committed but not yet paid, and current margin. Without asking anyone. Without a meeting. Without a spreadsheet.
The shift is from "margin is something we calculate at the end" to "margin is a property of the deal that updates every time something happens." That's not a reporting upgrade. That's a different operating model.
You don't need to rip out your accounting system or replace your PM tool. You need one system that becomes the source of truth for the deal — and every cost-generating event flows into it.
The practical sequence looks like this. First, decide where the deal lives. For most companies selling projects, the CRM is the right home, because the deal originates in sales and the same record needs to follow execution. Second, define every category of cost that can hit a project: subcontractors, internal hours, software, travel, third-party services. Third, connect the systems where those costs originate so they associate to the right deal automatically — by deal ID, project code, or whatever identifier is already consistent across systems.
The integration with accounting is usually the simplest part. If your accounting system already tracks costs by project or client, a single shared ID is enough to roll those numbers into the deal record. The harder part — and the part most teams skip — is being disciplined about what creates a cost event and making sure every one of them has a deal attached.
Once that's in place, the weekly margin report disappears, because the margin is visible the moment anyone opens the deal. The closeout meeting stops being a discovery process and starts being a confirmation of what everyone already knew.
If you're finding out about margin erosion at the end of a project, no amount of better Excel will fix it. The information you need exists — it's just scattered across systems that were never designed to give you the answer together.
If you want to see what real-time project margin visibility looks like when sales, operations, and costs live in the same system, this is the model we build for companies that sell projects: how we structure project visibility end-to-end. The page shows exactly how the deal, the tickets, the invoices, and the margin connect — before you ever talk to us.