Software people talk about margin as a property of the business model. Labor people talk about it as something you defend every single week, because in staffing you can watch it erode in real time.
Running Flatstaffing alongside software companies has made me think the labor version of this discipline is the more useful one, and that plenty of software businesses would be healthier if they adopted it.
In labor, margin is visible daily
Staffing margin is the spread between what a client pays and what the work costs — wages, burden, insurance, the hours nobody bills. It is thin enough that mistakes show up immediately.
Miss an overtime rule and you have worked a week for nothing. Underquote a shift and it loses money every day it runs. Let a client slide from forty-five to sixty days on payment and you are financing them. There is no cushion, so you develop reflexes: know the true cost of the unit, price with the exceptions included, and watch it weekly.
In software, margin hides
Software's supposed advantage is that the marginal cost of another customer is near zero. That is true, and it is also the thing that lets bad habits accumulate for years.
Because the gross margin looks excellent, nobody examines what sits underneath it. Then you notice:
- Support hours per customer are rising, and nobody tracks it by account
- Three enterprise clients each got a custom feature that only they use and someone maintains all three forever
- Infrastructure spend grew faster than revenue and nobody owns the number
- Onboarding takes a human two weeks, so growth is quietly capped by headcount
None of these show up in the headline margin for a long time. Each one is the software equivalent of underquoting a shift, and because there is no weekly reckoning, they compound.
The habits that transfer
Know the true unit cost. In staffing that is the fully loaded hour. In software it is the fully loaded customer — support, infrastructure, onboarding, and the maintenance of whatever you built for them. Most software teams cannot produce this number for a specific account. In labor, not knowing it is how you go out of business.
Price the exceptions. Staffing teaches you that the exception is where the money goes: the last-minute shift, the special certification, the client whose site takes an extra hour to reach. Software has exactly the same structure and rarely prices it. The enterprise client with unusual requirements is not the same product as the self-serve customer, and charging as though they are means the easy customers subsidize the hard ones.
Watch it weekly, not quarterly. Quarterly review means a bad trend runs for three months before anyone names it. In labor that is fatal, so you look constantly. Software can absorb the delay, which is exactly why it does.
Cash timing is separate from margin. A profitable staffing company can die waiting on receivables while making payroll every Friday. Software founders with annual prepayments often never learn this — until they hit a model where they do not, and discover that profit and cash are different things.
Where the analogy breaks
I don't want to overdraw it. Software genuinely does have leverage labor never will. A product improvement helps every customer at once; a better process in staffing helps one shift at a time. That difference is real and it is why I build software.
And a software business that obsesses over near-term margin can starve the investment that creates the leverage. Some of the most valuable things we build take a year to pay back. A labor operator's instincts, applied without judgment, would kill those projects in month two.
The point is not that software should be run like staffing. It is that the discipline labor forces on you — knowing your true unit cost, pricing the exceptions, watching weekly — is genuinely useful in a business that does not force it on you.
Running both is the closest thing I have to an unfair advantage. The staffing side keeps me honest about cost. The software side keeps me honest about leverage. Most operators only get one of those educations.