If you use job-costing software, you probably recognize a calculation like this:
A job sells for $10,000.
The crew costs $3,000.
Materials cost $1,500.
The software subtracts the costs from the revenue and shows $5,500 remaining.
Useful information.
But there is another question I have spent years trying to answer:
How much of the actual cost of operating the company did the hours on that job have to carry?
That question sounds like it should be easy.
The arithmetic is easy.
Keeping all the information behind the arithmetic accurate and current is not.
That problem eventually became one of the reasons I built PaintCurrent.
A profitable project is not necessarily profitable production
Most contractors understand direct project costs.
Labor.
Paint and materials.
Subcontractors.
Equipment or disposal that belongs specifically to a job.
Those costs should stay attached to the project that consumed them.
But a painting company also carries costs that don't belong cleanly to one project.
An office employee still gets paid.
A salesperson still gets paid.
The owner may receive a salary.
Field employees spend paid time in meetings, training, the shop, maintenance, loading, weather delays and other non-production activities.
Then there is rent, vehicles, insurance, software, advertising, accounting, recruiting, office expenses and everything else required to keep the company operating.
Those costs don't disappear because they aren't listed underneath a particular project.
The company's production has to support them.
That is why I care about overhead per production hour.
The denominator changes the meaning of overhead
Suppose a company carries $20,000 in overhead during a period.
Knowing the $20,000 matters.
But by itself, it doesn't tell me enough about production.
What I want to know is:
How much overhead did every hour of revenue-producing field work have to carry?
If the company generated 625 production hours during that period:
Now the number becomes operational.
A 100-hour project didn't just consume its direct wages and materials.
Those 100 hours also had to produce enough value to support roughly $3,200 of the company's operating cost during that period.
That's a very different way to look at job performance.
I call this metric:
True Job-Cost Overhead per Production Hour — TJCOPH
The formula itself is simple:
But the important words are actual and current.
What belongs in TJCOPH — and what doesn't
TJCOPH is not a method for throwing every company cost into one overhead bucket.
Quite the opposite.
The value of the metric depends on separating costs correctly.
Direct production payroll and its applicable employer burden belong with production labor.
Direct materials and subcontractors remain costs of the specific projects that consumed them.
What belongs in overhead is the cost of operating the company outside of direct production:
- non-production field labor and its related burden
- salaried staff and their related employer costs
- office and administrative costs
- vehicles
- rent
- software
- insurance
- advertising and marketing
- recruiting
- professional services
- and the other expenses required to operate the company
PaintCurrent was built to separate production from non-production labor and keep salaried labor outside direct field-job costing.
That distinction matters because otherwise you can create a very convincing-looking job margin that doesn't reflect the economic structure of the company.
Payroll is where ordinary job costing can start to drift
Consider a painter earning $30 per hour.
Many job-costing systems can take 10 hours worked and assign $300 of labor to a project.
Some systems let you create a "loaded" rate instead — perhaps $38 or $40 per hour — to approximate payroll taxes, workers' compensation or other employer costs.
That is better than using wages alone.
But I wanted something different.
I wanted the system to work from what payroll actually cost the company.
Actual employee wages.
Actual employer payroll costs.
Actual burden.
And actual hours.
PaintCurrent's labor model ties field time to projects and incorporates payroll-related employer costs rather than treating the employee's stored hourly wage as the final labor-cost number.
Then there is another distinction.
Suppose an employee gets paid for 40 hours:
35 hours painting customer projects.
5 hours in the shop.
The company paid for all 40 hours.
But economically, those hours did different things.
The 35 production hours belong to direct production labor.
The five shop hours did not produce project revenue.
The wages associated with those five hours — along with their share of employer burden — belong in overhead.
PaintCurrent's model specifically separates non-production labor from production labor and shifts the associated wages and burden into overhead.
That makes both numbers more meaningful.
Direct labor becomes more truthful.
And so does overhead.
Then salaries have to go somewhere
The same principle applies to salaried labor.
Sales.
Project management.
Administration.
Marketing.
Owner salary, depending on how the company is structured.
Those people may be essential to producing revenue, but their salaries aren't direct hourly painting labor on a specific house.
PaintCurrent keeps salaried staff separate from production-field metrics and places those costs in the company's overhead structure.
Now I can look at three numbers side by side:
Revenue per Production Hour
What is one hour of actual field production generating?
True Direct Labor Cost per Production Hour
What is that production labor actually costing after wages and employer burden?
True Job-Cost Overhead per Production Hour
How much of the company's operating cost must each production hour carry?
Those three numbers together tell me something that a project gross-margin percentage alone cannot.
This is where "job costing" can mean two different things
There is nothing wrong with project costing.
If a system tells you:
that is valuable.
It can tell you whether the production team stayed inside a labor budget.
It can tell you whether materials ran high.
It can identify jobs that performed well or poorly.
But that doesn't necessarily answer:
Did the production generate enough money to carry the company?
That's the distinction I think gets lost when every software product uses the phrase job costing.
Two products can both say they perform job costing while calculating substantially different things.
One may use wages.
Another may use a manually loaded labor rate.
Another may add materials and subcontractors.
What I wanted was:
actual production payroll and burden
plus
actual direct project costs
plus
the actual overhead those production hours have to support.
That is a different level of visibility.
Why I wanted TJCOPH to be a current KPI
A contractor can calculate overhead once a year.
Accounting can tell you what happened last year.
You can calculate it monthly.
With more work, you can maintain it weekly.
I did versions of this for years.
In 2006, I was running Excel on a Pocket PC because simply having meaningful business information with me while I was running the company was valuable.
The technology changed over time.
Eventually I was using Excel on an iPad.
Cloud software improved.
Estimating improved.
CRM improved.
Payroll improved.
Accounting improved.
Contractor software became dramatically more capable.
As cloud software matured, something started bothering me. There were now dozens of sophisticated contractor platforms, yet I still had not found anything that made me abandon the basic operating system I had been carrying forward since 2006.
I kept looking.
I kept trying software.
Some products had excellent features.
PaintScout became one of the tools I kept because it solved the estimating and sales side of the business well. But the spreadsheets remained.
Not because spreadsheets were better software.
They remained because the problem I originally built them to solve was still there.
Excel could calculate the number. That was never the problem.
This is an important distinction.
PaintCurrent wasn't built because overhead per production hour requires complicated mathematics.
It doesn't.
The problem was the labor required to keep everything behind the calculation current.
Actual hours.
Production versus non-production time.
Payroll.
Employer burden.
Materials.
Subcontractors.
Salaries.
Company expenses.
Bills.
Credit cards.
Customer payments.
Bank activity.
The spreadsheet could eventually tell me what happened.
But eventually was the problem.
Once a year gives you history.
Once a month gives you better history.
Once a week is much more useful — but requires substantially more work.
What I really wanted was:
Complete Current Visibility.
Not just a better calculation.
A current operating picture.
TJCOPH should move when the business moves
I also don't want overhead per production hour to be an annual estimate somebody enters into a settings screen and forgets about.
The company changes.
Hire an administrator?
Overhead changes.
Increase salaries?
Overhead changes.
Add another vehicle?
It changes.
Advertising increases?
It changes.
Your crews lose production time to weather?
The number changes again — because the same company expenses now have fewer production hours available to carry them.
Production becomes more efficient?
That matters too.
The economics of the company are moving continuously.
The KPI should move with them.
That is what makes TJCOPH more useful to me as a live operating metric rather than simply an accounting calculation.
Bank reconciliation and job costing are related — but they are not the same thing
There is another distinction I think is important to be honest about.
PaintCurrent tracks company financial activity and reconciles that activity against what actually happened in the bank.
But that does not mean every individual transaction must always be perfectly attributed to a specific project before the company's financial picture can be correct.
Those are two different questions.
Bank reconciliation asks:
Did we account for the money correctly?
Job attribution asks:
Which project, if any, should that cost belong to?
Direct material should be assigned to the project that consumed it whenever practical.
Subcontractor cost should stay with the relevant project.
But some expenses legitimately belong to overhead.
And sometimes job attribution may be uncertain or simply not worth forcing.
The company's financial ledger should not become wrong because someone cannot confidently decide which project consumed a particular expense.
Financial Accuracy First; Job Attribution Second.
That distinction matters because perfect-looking project costing built on forced assumptions is not necessarily better information.
Why the bank still matters
The bank is an important reality check.
The payroll system knows what payroll processed.
The time records know where employee hours went.
The expense records know what was purchased.
The project system knows what work was sold.
But cash ultimately moves somewhere.
PaintCurrent is designed to bring those operating and financial pieces into one picture rather than leaving the owner to mentally reconcile several separate systems.
The goal isn't to pretend every piece of information originated in one application.
It didn't.
The goal is to make the information agree enough to manage the company from it.
That is a very different philosophy from replacing every existing system.
The number I ultimately wanted to see
After years of spreadsheets, I wasn't looking for more reports.
I wanted a few numbers I could trust:
What are we producing per hour?
What is our production labor really costing per hour?
What does the company cost per production hour?
And ultimately:
What is left?
That screen is the reason I think this concept is easier to show than to explain.
Revenue per hour.
Actual direct labor per hour.
Actual overhead per hour.
Net per hour.
One current view.
Not because those four divisions are mathematically sophisticated.
Because getting all of the information underneath them current enough to trust is the hard part.
The biggest improvement wasn't saving time
PaintCurrent takes a fraction of the time that the spreadsheet system required.
That matters.
But it isn't the biggest difference.
The biggest difference is that I don't have to wait until I finish rebuilding the financial picture to know what's happening.
The information stays current enough to use while I'm actually running the company.
That's what I was trying to get to for years.
Not more features.
Not another dashboard.
Complete Current Visibility.
And TJCOPH — True Job-Cost Overhead per Production Hour — is one of the numbers that makes that possible.
The question I would ask your job-costing software
Not:
Does it do job costing?
Almost everything says it does.
Ask instead:
Does it use actual payroll?
Does it account for actual employer burden?
Does it separate direct production labor from indirect labor and salaries?
Does it keep direct materials and subcontractors with the projects that consumed them?
Does it calculate your actual company overhead per production hour?
Does it reconcile the company to the bank without forcing every dollar onto a job?
Those are the questions I wanted PaintCurrent to answer.
If your current software cannot answer all six, it may still provide very useful project costing. But it may not be showing you the complete economics of producing the work.