Project Profitability Is Decided at the Estimate and the Time Code, Not the Invoice.
Most services firms learn how profitable a project was after it ended. The final invoice goes out, someone compares the fees with the cost of the hours, and the result is a percentage in a spreadsheet. The number is accurate. It also arrives too late to change anything, and it is the answer to a question that was settled months earlier.
Project profitability is determined at two moments, neither of which is the invoice. The first is when the estimate is written. The second is when the first hour is logged against it. If those two moments use different structures, nobody can tell whether the project is going well until it is over.
A typical estimate is a number built from a spreadsheet: so many days of design, so many of development, a contingency. The client sees the total, and the spreadsheet is filed. The structure behind it, the phases, the roles, the rates and the day counts, lives in one file and one person's head.
Then the project starts. The team logs time against a project code, because that is what the timesheet offers. Maybe there is a task list, maybe not. After a month the project has fifty hours logged against it, and the question the project manager is asked is whether that is on plan.
There is no way to tell. The estimate was in phases and roles and the actuals are in one lump. Fifty hours against a total of six hundred is eight percent, and the project is perhaps ten percent through its calendar, so it looks fine. But the fifty hours may all be in the phase that was meant to take thirty, and the senior role may have absorbed half of what the estimate gave to the junior one. Both facts would change the forecast, and neither is visible.
We described the entry itself in time tracking for consultants: the shape of the time entry decides what can be known. This is the other half, the shape of the estimate.
The fix is not elaborate. It is to write the estimate in the structure the time will be coded in and to use that structure from the first day.
Phases. Three to six, named the way the client would name them: discovery, design, build, test, handover. The estimate carries hours per phase. The time code carries the phase.
Roles. The estimate assumes a mix, such as a senior who plans and reviews, a consultant who builds, an analyst who tests. It carries hours per role at a rate. The time entry carries the role the person was in for that entry, which is not always their job title, and the system needs to know that.
A short list of non-estimate codes. Rework, change requests, waiting on client. These exist so that unplanned hours have a named home rather than being smeared across the phases they happened to touch.
With these three in the estimate and in the timesheet, any hour can be compared with its estimate by phase and role. That is a table of perhaps twelve cells, each with a plan and an actual.
Waiting for the end of a project means the variance is history. The better moment is when half the estimated hours have been logged, whatever the calendar says.
At that point the twelve cells show where the estimate is holding and where it is not. A phase that has used ninety percent of its hours with half the work done is the signal. So is a senior role running at twice its allocation, which usually means the junior work was not done and the senior picked it up.
The conversation that follows is useful because it is early. The project manager can ask whether the remaining phases need reshaping, whether the client should be told about a scope change while the original is still arguable, or whether the senior should hand something back. At the end of the project the same facts are a post-mortem. At the halfway burn they are a decision.
The check takes thirty minutes if the data is there. If it is not, the effort goes into getting the data, which is the point: the halfway check is what makes the structure worth keeping.
A project is estimated at 600 hours: 60 for discovery, 120 for design, 300 for build, 80 for test and 40 for handover. At 300 logged hours the firm runs the check. Discovery has used 75 of its 60, design is complete at 130, and build has used 80 of 300 with the build roughly a quarter done. The senior role has logged 110 hours against an allocation of 60.
The table says three things at once. Discovery overran by a quarter because the client's requirements arrived late. Design overran slightly. And the senior has absorbed work meant for the consultant, which will not continue if the build team is brought up to speed. The project is not in trouble by total hours, since half were used at about half the work, but the forecast at completion is roughly 40 hours over, and the cause is known, so the conversation with the client about the late requirements can happen while the facts are fresh.
Without the structure the same project reports 300 of 600 hours used and looks on plan. The overrun is discovered at handover, at which point it can only be absorbed.
Three habits sustain it. First, the estimate is entered into the project system by phase and role, not attached as a file. Second, the timesheet offers only the phases and roles of the project in question, so an entry cannot be made against a structure that does not exist. Third, the halfway check is a calendar event for every project over a size the firm decides, owned by the project manager and read by the partner.
None of this needs a heavy system. It needs a project tool that can hold phases and roles and a timesheet that is wired to it. We looked at what a project tool does and does not cover in a project tool is not a PSA, and the gaps listed there are the ones this structure closes.
An unexpected benefit appears after a few projects. The firm has a record of what each phase and role actually cost on past work, so the next estimate starts from data rather than memory. Estimates become more accurate, and the firm starts to see which kinds of work it consistently underestimates, which is a pricing decision and not a delivery one.
We set up the structure with the people who write the estimates and run the projects: phases, roles, the non-estimate codes, the timesheet wiring and the halfway check. Discovery is no-risk: we take one finished project, rebuild its estimate in phases and roles, and show where the variance was visible and when, and you pay only if you go ahead. The build carries a guaranteed estimate, so if we estimate low, we absorb the difference.
The invoice reports how a project went. The estimate and the time code decide it.
In a no-risk discovery we look at your CRM, finance and operations systems and who owns each part, and show what a connected system would do differently. You pay only if you proceed. Or see how we approach it.
More on the same problem:
"Something isn't working." "We're outgrowing our tools." "We're afraid to make the wrong move." No-Risk Discovery is a short, practical conversation that gets you clarity before you commit to anything big. We'll tell you if we're a fit. If we're not, we'll tell you that too.
Say who you are and ask. A person replies within one business day.