Table of contents5 sections
The project has a high contract value, invoices are issued on schedule, and the client keeps ordering further tasks. At the sales level, everything looks good.
The problem appears only when the company checks how many people were involved in delivery, how long they worked and what additional costs had to be incurred.
It turns out that the project required a senior developer, an architect, a tester, a UX designer and a Project Manager. Extra meetings appeared, along with unplanned revisions, post-implementation support and tasks that were not included in the first quote.
Revenue looks good, but the profit is small.
We know what it is like when a project generates a lot of invoices and still does not improve the company’s result. The team is busy, the client is happy, and the owner discovers only after a few months that delivery has consumed almost all of the planned margin.
An unprofitable IT project rarely looks problematic from day one. Most often it gradually engages more and more time and expensive resources, while the contract value stays the same.
The project has a high contract value, invoices are issued on schedule, and the client keeps ordering further tasks. At the sales level, everything looks good.
Why can a high-value project have a low margin?
The value of invoices does not show profitability. It only tells you how much the company sold to the client.
To assess the result of a project, you have to take into account all the costs of delivering it.
The project engages the most expensive people on the team
The original quote may assume that most tasks will be done by a mid developer with occasional support from a senior. In practice the project turns out to be more complex.
The senior developer starts taking part in daily consultations, the architect solves technical problems, and the Project Manager spends more and more time communicating with the client.
The number of hours may still fit within the agreed budget, but the cost structure of those hours changes.
Example:
- 100 hours of a junior developer at a cost of 80 PLN per hour: 8,000 PLN,
- 100 hours of a senior developer at a cost of 200 PLN per hour: 20,000 PLN.
The project used the same amount of time, but its cost rose by 12,000 PLN.
Unplanned activities are not visible in the budget
Part of the work does not make it into the original estimate because it appears only during delivery.
These may include:
- additional meetings with the client,
- further rounds of analysis,
- revisions after a change in a business decision,
- user support,
- preparing additional documentation,
- work related to data migration,
- problems with the client’s infrastructure,
- cross-team consultations,
- fixing bugs resulting from incomplete requirements.
Each of these activities costs the company time and money. If it is not assigned to the project, the profitability report will understate the real cost.
Scope creep increases cost without increasing revenue
The client reports small changes, which the team carries out without a separate quote. One extra feature, another view variant or an extension of an integration does not seem like a big problem.
After a few months, however, it turns out that the scope has grown by dozens or hundreds of hours.
If the project is billed under the Fixed Price model, every extra hour lowers the margin. Under a subscription model, the problem appears when the client uses more time than the monthly fee allows for.
External costs are not assigned to the project
A project may require additional:
- licences,
- cloud services,
- testing tools,
- components,
- subcontractors,
- consultants,
- server environments,
- travel and meeting costs.
If the expenses stay in the company’s general costs, the project looks more profitable than it really is.
The result is analysed only after the work is finished
The biggest mistake is waiting for the final settlement.
After the project is closed, all you can do is state that the margin was too low. You cannot get back the hours worked, limit the additional activities or change the team.
That is why cost and profitability should be monitored on an ongoing basis.
How to spot an unprofitable IT project before it ends?
An effective analysis should combine data on revenue, working time, specialists’ costs, external expenses and the work needed to finish the project.
1. Convert time into the cost of specific specialists
The number of hours alone is not enough.
Each person should have an individual cost rate that takes into account, among other things:
- salary or B2B invoice,
- employer costs,
- holidays and absences,
- workstation costs,
- tools,
- non-billable time,
- management costs.
Then every hour reported to the project should automatically increase its cost.
The basic formula:
Project labour cost = sum of each specialist’s hours worked × their cost rate
This shows not only how much time was used, but also what its financial value was.
2. Compare cost with delivery progress
Using 70% of the budget does not have to mean a problem if 90% of the scope has already been completed.
If, however, the project has used 70% of the budget and only half of the work is done, the risk of overrun is high.
The Project Manager should regularly compare:
- the percentage of hours used,
- the cost incurred,
- the percentage of scope completed,
- the number of open tasks,
- the cost of the remaining work,
- the forecast final margin.
3. Separate the base cost from extra work
Every scope change should be recorded as a separate item.
It is worth indicating:
- who reported the change,
- what it concerns,
- whether it falls within the contract,
- how many hours it requires,
- which people will be needed,
- what its cost is,
- whether it has been quoted separately,
- how it will affect the deadline and margin.
This way the company can see what part of the cost comes from the original delivery and what part from the client’s additional expectations.
4. Forecast the final cost, not only the cost incurred
A project may currently look profitable because a large part of the work is still waiting to be done.
Example:
- contract value: 200,000 PLN,
- cost incurred: 90,000 PLN,
- current difference: 110,000 PLN,
- forecast cost of the remaining work: 80,000 PLN,
- expected final cost: 170,000 PLN,
- forecast margin: 30,000 PLN.
The current difference between revenue and the cost incurred is not the final margin.
The most important indicator is the answer to the question:
How much will the project cost if we keep the current pace and way of working?
How did we solve the detection of unprofitable projects in Administy?
While running agencies, we delivered projects that looked very good at first glance.
They had a high contract value, regularly issued invoices and a large number of hours worked. They were important for the team and the client portfolio.
Only a closer analysis showed that some of them engaged the most expensive people and required many unplanned activities.
The problem was that the data was scattered:
- revenue was in invoices,
- working time in the project system,
- employee rates in separate spreadsheets,
- subcontractor invoices in cost documents,
- additional expenses in bank transactions,
- scope and schedule in yet other tools.
We saw turnover, but we did not always see the full cost of a project.
That is why in Administy we created a profitability report that combines:
- contract value,
- amounts invoiced,
- funds actually received,
- team working time,
- the individual cost of each specialist,
- subcontractor invoices,
- external costs,
- hours remaining to be used,
- forecast cost to completion,
- current and expected margin.
Working time imported from the project system is automatically assigned to the project and converted according to the cost of the specific person.
This lets us see the difference between a project that used:
- 300 hours of a cheaper team,
- and a project that used 300 hours of seniors and management staff.
The number of hours can be identical, but the financial result completely different.
The report also lets us notice that a project:
- generates high revenue but low profit,
- requires too much involvement from seniors,
- exceeds the assumed management cost,
- contains a lot of unplanned work,
- engages subcontractors outside the original budget,
- needs more funds to finish than assumed,
- may end with a low or negative margin.
This lets us react before the project is closed.
Depending on the source of the problem, you can:
- change the team composition,
- limit the involvement of the most expensive specialists,
- organise communication with the client,
- stop unagreed revisions,
- quote the extra work,
- renegotiate the scope,
- change the schedule,
- improve the estimate for the remaining stages.
The most important change is separating the sales value from the real financial value of the project.
A project worth 300,000 PLN is not always better than one worth 100,000 PLN. If the first engages most of the team and ends with a 5% margin, while the second has a simple scope and a 35% margin, the smaller project may generate much more value for the company.
A big project does not always mean a good project
An unprofitable IT project can stay invisible for a long time if the company analyses only the contract value, invoices and the number of hours.
The true result appears only after taking into account the cost of specific specialists, external expenses, additional scope and the work needed to finish.
The earlier the company sees the forecast margin, the greater the chance that it will limit the loss and improve the way it delivers.
Check which projects really earn money
Administy helps combine revenue, working time, team cost, external expenses and forecast margin in one report.
Book an Administy demo and check which projects generate real profit and which only generate high turnover and a heavy load on the team.
